home *** CD-ROM | disk | FTP | other *** search
/ Carousel / CAROUSEL.cdr / mactosh / code / p_serlib.sit / Serial Library Source Code / serial.readFile.dll.c < prev    next >
C/C++ Source or Header  |  1989-07-27  |  10KB  |  362 lines
  1. /***********************************************************************/
  2. /*    
  3. /*    serial.readFile.dll.c
  4. /*    by Atul Butte
  5. /*    Copyright ⌐ 1989 by Microsoft Corporation
  6. /*    All Rights Reserved
  7. /*
  8. /*    version 1.0
  9. /*    
  10. /*    
  11. /*    This CALL/REGISTER will read from the serial port the number of chars
  12. /*    specified and will put them into a file.
  13. /*    
  14. /*    Excel usage:
  15. /*    
  16. /*    = Register( "serial library", "serial.readFile", "IHHJCD" )
  17. /*    = Call( ref, portNumber, numberChars, maxTime, readConfigStr, fileName )
  18. /*    
  19. /*    where
  20. /*        portNumber        = number of port (1 = modem, 2 = printer)
  21. /*        numberChars        = number of characters to read
  22. /*        maxTime            = maximum amount of time to wait for characters
  23. /*                          in 1/60 second units
  24. /*        readConfigStr    = configuration of communications protocol, etc
  25. /*        fileName        = name of file in which to store characters
  26. /*    
  27. /***********************************************************************/
  28.  
  29. /***********************************************************************/
  30. /*
  31. /*    D E F I N E S
  32. /*
  33. /***********************************************************************/
  34.  
  35. #define ROUTINE_NAME    "serial.readFile"
  36. #define hNIL 0L
  37. #define pNIL 0L
  38. #define kcchBuff        64
  39.  
  40. /***********************************************************************/
  41. /*
  42. /*    I N C L U D E S
  43. /*
  44. /***********************************************************************/
  45.  
  46. #include "serial.h"
  47. #include "error.h"
  48. #include "get_port.h"
  49. #include "get_read_flags.h"
  50.  
  51. /***********************************************************************/
  52. /*
  53. /*    P R O T O T Y P E S
  54. /*
  55. /***********************************************************************/
  56.  
  57. short open_file( char *pstFilename );
  58. void close_file( short refnum, char *pch, unsigned short dch );
  59. Boolean store_character( short refnum, char cRead, char *pch, unsigned short *dch );
  60.  
  61. /***********************************************************************/
  62. /*
  63. /*    main
  64. /*
  65. /***********************************************************************/
  66.  
  67. pascal short main( port, cchDesired, timeDur, pszConfig, pstFilename )
  68.  
  69.     unsigned short            port;                    /* serial port to use */
  70.     unsigned short            cchDesired;                /* number of characters desired */
  71.     unsigned long            timeDur;                /* maximum time to wait for chars (in ticks) */
  72.     char                    *pszConfig;                /* communications configuration string */
  73.     register char            *pstFilename;            /* name of file in which to save characters */
  74.     
  75. {
  76.     register OSErr            err;                    /* result code from Toolbox routines */
  77.     ParamBlockRec            param;                    /* parameter block for read/write */
  78.     
  79.     Boolean                    fEcho = false;            /* flag for echoing characters */
  80.     Boolean                    fEdit = false;            /* flag for allowing edit characters */
  81.     Boolean                    fStripLF = false;        /* flag for stripping line feeds */
  82.     Boolean                    fStrip8Bit = false;        /* flag for stripping high bit */
  83.     Boolean                    fAddLF = false;            /* flag for adding LF after CR */
  84.     Boolean                    fIgnore = false;        /* flag for ignoring escape chars */
  85.     
  86.     register short            cch = 0;                /* number of characters received */
  87.     long                    cchBuff = 0;            /* number of characters waiting in read buffer */
  88.     register unsigned long    timeStop;                /* time at which to stop */
  89.     short                    refIn;                    /* reference number for input port */
  90.     short                    refOut;                    /* reference number for output port */
  91.     char                    chRead;                    /* buffer used to read a character */
  92.     register char            ch;                        /* character read */
  93.     char                    echoBackspace[3];        /* characters to send to echo Backspace */
  94.     char                    echoLinefeed;            /* characters to send to echo Linefeed */
  95.     
  96.     char                    *pch;                    /* buffer used in file reading */
  97.     unsigned short            ichBuff = 0;            /* index in buffer */
  98.     short                    refFile;                /* reference number for file */
  99.     
  100.     RememberA0();
  101.     SetUpA4();
  102.     
  103.     if( pszConfig == pNIL ) {
  104.         display_error( "The third parameter must be a configuration string." );
  105.         RestoreA4( );
  106.         return( errParam );
  107.     }
  108.     if( pstFilename == pNIL ) {
  109.         display_error( "The fifth parameter must be a file name." );
  110.         RestoreA4( );
  111.         return( errParam );
  112.     }
  113.     if( *pstFilename == 0 ) {
  114.         display_error( "The fifth parameter must be a file name." );
  115.         RestoreA4( );
  116.         return( errParam );
  117.     }
  118.  
  119.     err = get_port( port, &refIn, &refOut );
  120.     if( err != noErr ) {
  121.         display_error( "Illegal port number." );
  122.         RestoreA4( );
  123.         return( err );
  124.     }
  125.         
  126.     pch = NewPtr( kcchBuff );
  127.     if( pch == pNIL ) {
  128.         display_error( "Not enough memory to allocate buffer." );
  129.         RestoreA4( );
  130.         return( errMemory );
  131.     }
  132.     ichBuff = 0;
  133.     
  134.     if( ( refFile = open_file( pstFilename ) ) == 0 ) {
  135.         RestoreA4( );
  136.         return( errDiskWrite );
  137.     }
  138.     
  139.     get_read_flags( pszConfig, &fEcho, &fEdit, &fStripLF, &fStrip8Bit, &fAddLF, &fIgnore );
  140.     
  141.     if( fEcho ) {
  142.         echoBackspace[0] = kchBackspace;
  143.         echoBackspace[1] = ' ';
  144.         echoBackspace[2] = kchBackspace;
  145.         if( fAddLF ) {
  146.             echoLinefeed = kchLinefeed;
  147.         }
  148.     }
  149.     
  150.     timeStop = TickCount( ) + timeDur;
  151.     
  152.     while( cch < cchDesired ) {
  153.     
  154.         if( ( timeDur != 0 ) && ( TickCount( ) >= timeStop ) ) {
  155.             break;
  156.         }
  157.         err = SerGetBuf( refIn, &cchBuff );
  158.         if( err != noErr ) {
  159.             display_error( "Error trying to count buffer." );
  160.             err = errSerialGetBuf;
  161.             goto CleanExit;
  162.         }
  163.         if( cchBuff == 0 )
  164.             continue;
  165.         param.ioParam.ioReqCount = 1;
  166.         param.ioParam.ioBuffer = &chRead;
  167.         param.ioParam.ioRefNum = refIn;
  168.         err = PBRead( ¶m, false );
  169.         if( err != noErr ) {
  170.             display_error( "Error reading from serial port." );
  171.             err = errSerialRead;
  172.             goto CleanExit;
  173.         }
  174.  
  175.         ch = chRead;
  176.  
  177.         if( ( (ch == kchBackspace) || (ch == kchDelete) ) && (fEdit) ) {
  178.             cch -= 2;
  179.             if( cch >= -1 ) {
  180.                 cch = -1;
  181.             }
  182.             if( fEcho ) {
  183.                 param.ioParam.ioReqCount = 3;
  184.                 param.ioParam.ioRefNum = refOut;
  185.                 param.ioParam.ioBuffer = echoBackspace;
  186.                 err = PBWrite( ¶m, false );
  187.                 if( err != noErr ) {
  188.                     display_error( "Error echoing backspace to serial port." );
  189.                     err = errSerialWrite;
  190.                     goto CleanExit;
  191.                 }
  192.             }
  193.         } else if( fEcho ) {        /* if not a backspace or delete */
  194.             param.ioParam.ioReqCount = 1;
  195.             param.ioParam.ioRefNum = refOut;
  196.             err = PBWrite( ¶m, false );
  197.             if( err != noErr ) {
  198.                 display_error( "Error echoing to serial port." );
  199.                 err = errSerialWrite;
  200.                 goto CleanExit;
  201.             }
  202.             if( (ch == kchReturn) && (fAddLF) ) {
  203.                 param.ioParam.ioReqCount = 1;
  204.                 param.ioParam.ioRefNum = refOut;
  205.                 param.ioParam.ioBuffer = &echoLinefeed;
  206.                 err = PBWrite( ¶m, false );
  207.                 if( err != noErr ) {
  208.                     display_error( "Error echoing linefeed to serial port." );
  209.                     err = errSerialWrite;
  210.                     goto CleanExit;
  211.                 }
  212.             }
  213.         }
  214.  
  215.         if( fStrip8Bit ) {
  216.             ch &= 0x7f;
  217.         }
  218.  
  219.         if( (ch == kchLinefeed) && (fStripLF) ) {
  220.             cch--;
  221.         } else {
  222.             if( !store_character( refFile, ch, pch, &ichBuff ) ) {
  223.                 err = errDiskWrite;
  224.                 goto CleanExit;
  225.             }
  226.         }
  227.         cch++;
  228.     }
  229.  
  230.     
  231.     if( cch < cchDesired ) {
  232.         err = errTimeOut;
  233.     } else {
  234.         err = noErr;
  235.     }
  236.     
  237. CleanExit:
  238.  
  239.     close_file( refFile, pch, ichBuff );
  240.     RestoreA4();
  241.     return( err );
  242. }
  243.  
  244. /***********************************************************************/
  245. /*
  246. /*    open_file
  247. /*
  248. /***********************************************************************/
  249.  
  250. short open_file( pstFilename )
  251.  
  252.     register char            *pstFilename;            /* name of file in which to save characters */
  253.  
  254. {
  255.     short                    refFile;                /* reference number for file */
  256.     register OSErr            err;                    /* result code from Toolbox routines */
  257.  
  258.     err = FSOpen( pstFilename, 0, &refFile );
  259.     if( err == fnfErr ) {
  260.         err = Create( pstFilename, 0, 'XCEL', 'TEXT' );
  261.         if( err != noErr ) {
  262.             display_error( "Error creating file." );
  263.             return( 0 );
  264.         }
  265.         err = FSOpen( pstFilename, 0, &refFile );
  266.         if( err != noErr ) {
  267.             display_error( "Error opening file." );
  268.             return( 0 );
  269.         }
  270.     } else if( err == noErr ) {
  271.         err = SetEOF( refFile, 0L );
  272.         if( err != noErr ) {
  273.             display_error( "Error deleting existing file." );
  274.             return( 0 );
  275.         }
  276.     } else {
  277.         display_error( "Error opening file." );
  278.         return( 0 );
  279.     }
  280.     return( refFile );
  281. }
  282.  
  283. /***********************************************************************/
  284. /*
  285. /*    close_file
  286. /*
  287. /***********************************************************************/
  288.  
  289. void close_file( refFile, pch, ichBuff )
  290.  
  291.     short                    refFile;                /* reference number for file */
  292.     char                    *pch;                    /* buffer used in file reading */
  293.     unsigned short            ichBuff;                /* index in buffer */
  294.     
  295. {
  296.     register OSErr            err;                    /* result code from Toolbox routines */
  297.     long                    cch;                    /* number of character left in buffer */
  298.     
  299.     if( ichBuff > 0 ) {
  300.         cch = ichBuff;
  301.         err = FSWrite( refFile, &cch, pch );
  302.         if( err == dskFulErr ) {
  303.             display_error( "Disk full error." );
  304.         } else if( err == vLckdErr ) {
  305.             display_error( "The volume is locked." );
  306.         } else if( err != noErr ) {
  307.             display_error( "Error in writing to file." );
  308.         }
  309.     }
  310.     
  311.     err = FSClose( refFile );
  312.     if( err != noErr ) {
  313.         display_error( "Error closing file." );
  314.     }
  315.     
  316.     DisposPtr( pch );
  317. }
  318.  
  319. /***********************************************************************/
  320. /*
  321. /*    store_character
  322. /*
  323. /***********************************************************************/
  324.  
  325. Boolean store_character( refFile, ch, pch, pichBuff )
  326.  
  327.     short                    refFile;                /* reference number for file */
  328.     register char            ch;                        /* character read */
  329.     char                    *pch;                    /* buffer used in file reading */
  330.     unsigned short            *pichBuff;                /* index in buffer */
  331.     
  332. {
  333.     register OSErr            err;                    /* result code from Toolbox routines */
  334.     long                    cch;                    /* number of character left in buffer */
  335.     
  336.     if( *pichBuff < kcchBuff ) {
  337.         pch[*pichBuff] = ch;
  338.         ( *pichBuff )++;
  339.     } else {
  340.         cch = kcchBuff;
  341.         err = FSWrite( refFile, &cch, pch );
  342.         if( err == dskFulErr ) {
  343.             display_error( "Disk full error." );
  344.             return( false );
  345.         } else if( err == vLckdErr ) {
  346.             display_error( "The volume is locked." );
  347.             return( false );
  348.         } else if( err != noErr ) {
  349.             display_error( "Error in writing to file." );
  350.             return( false );
  351.         }
  352.         
  353.         *pichBuff = 1;
  354.         *pch = ch;
  355.     }
  356.     return( true );
  357. }
  358.  
  359. #include "get_port.c"
  360. #include "get_read_flags.c"
  361.  
  362.